Hbase协处理器构建二级索引（Elasticsearch存储）

最新推荐文章于 2023-09-06 09:38:16 发布
最新推荐文章于 2023-09-06 09:38:16 发布
阅读量7k 收藏 6
点赞数 1
分类专栏： hbase elasticsearch 文章标签： elasticsearch hbase 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/soldiers_A/article/details/115676203
版权

一、HBase协处理器简介

  1. 协处理器介绍

二、实现思路

2.1 Observer协处理器部分函数介绍（后续将使用这两个函数实现二级索引）

  1. postPut：该函数在 put 操作执 行后会被 Region Server 调用
  2. postDelete：该函数将在执行删除后被Region Server 调用
  • 思路：
  • 1.使用Elasticsearch作为索引库
  • 2.我们可以利用postPut回调函数，在往hbase插入数据时，执行Elasticsearch插入操作
  • 3.我们可以利用 postDelete回调函数，在删除hbase数据时，执行Elasticsearch删除操作

三、协处理器实现代码

  • HBase协处理器（服务）代码
package xxx.xxx.hbase.coprocessor;


import xxx.xxx.es.util.ESClient;
import xxx.xxx.es.util.ElasticSearchBulkOperator;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CellUtil;
import org.apache.hadoop.hbase.CoprocessorEnvironment;
import org.apache.hadoop.hbase.client.Delete;
import org.apache.hadoop.hbase.client.Durability;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.coprocessor.ObserverContext;
import org.apache.hadoop.hbase.coprocessor.RegionCoprocessor;
import org.apache.hadoop.hbase.coprocessor.RegionCoprocessorEnvironment;
import org.apache.hadoop.hbase.coprocessor.RegionObserver;
import org.apache.hadoop.hbase.util.Bytes;
import org.apache.hadoop.hbase.wal.WALEdit;
import org.apache.log4j.Logger;

import java.io.IOException;
import java.util.*;

/**
 * HBase 二级索引通用协处理器
 * 装载协处理器时,添加ES索引名和type名即可
 */
public class UniversalHBase2Index implements RegionObserver , RegionCoprocessor {

    private static final Logger LOG = Logger.getLogger(UniversalHBase2Index.class);

    private String index;
    private String type;
    public Optional<RegionObserver> getRegionObserver() {
        return Optional.of(this);
    }

    @Override
    public void start(CoprocessorEnvironment env) throws IOException {
        // init ES client
        ESClient.initEsClient();
        Configuration configuration = env.getConfiguration();
        index = configuration.get("index");
        type = configuration.get("type");
        LOG.info("****init start*****");
    }

    @Override
    public void stop(CoprocessorEnvironment env) throws IOException {
        ESClient.closeEsClient();
        // shutdown time task
        ElasticSearchBulkOperator.shutdownScheduEx();
        LOG.info("****end*****");
    }

    @Override
    public void postPut(ObserverContext<RegionCoprocessorEnvironment> e, Put put, WALEdit edit, Durability durability) throws IOException {
        String indexId = new String(put.getRow());
        try {
            NavigableMap<byte[], List<Cell>> familyMap = put.getFamilyCellMap();
            Map<String, Object> infoJson = new HashMap<>();
            Map<String, Object> json = new HashMap<>();
            for (Map.Entry<byte[], List<Cell>> entry : familyMap.entrySet()) {
                for (Cell cell : entry.getValue()) {
                    String key = Bytes.toString(CellUtil.cloneQualifier(cell));
                    String value = Bytes.toString(CellUtil.cloneValue(cell));
                    json.put(key, value);
                }
            }
            // set hbase family to es
            infoJson.put("fn", json);
            LOG.info(json.toString());
            ElasticSearchBulkOperator.addUpdateBuilderToBulk(ESClient.client.prepareUpdate(index,type, indexId).setDocAsUpsert(true).setDoc(json));
            LOG.info("**** postPut success*****");
        } catch (Exception ex) {
            LOG.error("observer put  a doc, index [ " + "user_test" + " ]" + "indexId [" + indexId + "] error : " + ex.getMessage());
        }
    }

    @Override
    public void postDelete(ObserverContext<RegionCoprocessorEnvironment> e, Delete delete, WALEdit edit, Durability durability) throws IOException {
        String indexId = new String(delete.getRow());
        try {
            ElasticSearchBulkOperator.addDeleteBuilderToBulk(ESClient.client.prepareDelete(index,type, indexId));
            LOG.info("**** postDelete success*****");
        } catch (Exception ex) {
            LOG.error(ex);
            LOG.error("observer delete  a doc, index [ " + "user_test" + " ]" + "indexId [" + indexId + "] error : " + ex.getMessage());
        }
    }
}
  • 工具类代码
    • Elasticsearch 客户端连接代码
package xxx.xxx.es.util;


import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.elasticsearch.client.Client;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.transport.TransportAddress;
import org.elasticsearch.transport.client.PreBuiltTransportClient;

import java.net.InetAddress;
import java.net.UnknownHostException;

/**
 * ES Cleint class
 */
public class ESClient {

    public static Client client;

    private static final Log log = LogFactory.getLog(ESClient.class);
    /**
     * init ES client
     */
    public static void initEsClient() throws UnknownHostException {
        log.info("初始化es连接开始");

        System.setProperty("es.set.netty.runtime.available.processors", "false");

        Settings esSettings = Settings.builder()
                .put("cluster.name", "log_cluster")//设置ES实例的名称
                .put("client.transport.sniff", true)
                .build();
        //填写自己公司ES集群地址即可
        client = new PreBuiltTransportClient(esSettings)
                .addTransportAddress(new TransportAddress(InetAddress.getByName("10.248.xxx.01"), 9300))
                .addTransportAddress(new TransportAddress(InetAddress.getByName("10.248.xxx.02"), 9300))
                .addTransportAddress(new TransportAddress(InetAddress.getByName("10.248.xxx.02"), 9300));

        log.info("初始化es连接完成");

    }

    /**
     * Close ES client
     */
    public static void closeEsClient() {
        client.close();
        log.info("es连接关闭");
    }
}
  • Elasticsearch 客户端操作工具（插入或删除）
package com.xxx.es.util;


import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.elasticsearch.action.bulk.BulkRequestBuilder;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.delete.DeleteRequestBuilder;
import org.elasticsearch.action.support.WriteRequest;
import org.elasticsearch.action.update.UpdateRequestBuilder;

import java.net.UnknownHostException;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;


public class ElasticSearchBulkOperator {

    private static final Log LOG = LogFactory.getLog(ElasticSearchBulkOperator.class);

    private static final int MAX_BULK_COUNT = 10000;

    private static BulkRequestBuilder bulkRequestBuilder = null;

    private static final Lock commitLock = new ReentrantLock();

    private static ScheduledExecutorService scheduledExecutorService = null;
    static {
        // 初始化  bulkRequestBuilder
        bulkRequestBuilder = ESClient.client.prepareBulk();
        bulkRequestBuilder.setRefreshPolicy(WriteRequest.RefreshPolicy.IMMEDIATE);

        // 初始化线程池大小为1
        scheduledExecutorService = Executors.newScheduledThreadPool(1);

        //创建一个Runnable对象，提交待写入的数据，并使用commitLock锁保证线程安全
        final Runnable beeper = () -> {
            commitLock.lock();
            try {
                LOG.info("Before submission bulkRequest size : " +bulkRequestBuilder.numberOfActions());
                //提交数据至es
                bulkRequest(0);
                LOG.info("After submission bulkRequest size : " +bulkRequestBuilder.numberOfActions());
            } catch (Exception ex) {
                System.out.println(ex.getMessage());
            } finally {
                commitLock.unlock();
            }
        };

        //初始化延迟10s执行 runnable方法，后期每隔30s执行一次
        scheduledExecutorService.scheduleAtFixedRate(beeper, 10, 30, TimeUnit.SECONDS);

    }
    public static void shutdownScheduEx() {
        if (null != scheduledExecutorService && !scheduledExecutorService.isShutdown()) {
            scheduledExecutorService.shutdown();
        }
    }
    private static void bulkRequest(int threshold) {
        if (bulkRequestBuilder.numberOfActions() > threshold) {
            BulkResponse bulkItemResponse = bulkRequestBuilder.execute().actionGet();
            if (!bulkItemResponse.hasFailures()) {
                bulkRequestBuilder = ESClient.client.prepareBulk();
            }
        }
    }

    /**
     * add update builder to bulk
     * use commitLock to protected bulk as thread-save
     * @param builder
     */
    public static void addUpdateBuilderToBulk(UpdateRequestBuilder builder) {
        commitLock.lock();
        try {
            bulkRequestBuilder.add(builder);
            bulkRequest(MAX_BULK_COUNT);
        } catch (Exception ex) {
            LOG.error(" update Bulk " + "gejx_test" + " index error : " + ex.getMessage());
            try {
                ESClient.initEsClient(); //初始化连接
                Thread.sleep(500);
            } catch (Exception e) {
                e.printStackTrace();
            }
        } finally {
            commitLock.unlock();
        }
    }

    /**
     * add delete builder to bulk
     * use commitLock to protected bulk as thread-save
     *
     * @param builder
     */
    public static void addDeleteBuilderToBulk(DeleteRequestBuilder builder) {
        commitLock.lock();
        try {
            bulkRequestBuilder.add(builder);
            bulkRequest(MAX_BULK_COUNT);
        } catch (Exception ex) {
            LOG.error(" delete Bulk " + "gejx_test" + " index error : " + ex.getMessage());
        } finally {
            commitLock.unlock();
        }
    }
}
  • pom文件
<properties>
        <hadoop.version>3.0.0</hadoop.version>
        <hbase.version>2.0.0</hbase.version>
        <elasticsearch.version>6.3.0</elasticsearch.version>
        <hutool.version>5.3.10</hutool.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-server</artifactId>
            <version>2.0.6</version>
            <exclusions>
                <exclusion>
                    <artifactId>jdk.tools</artifactId>
                    <groupId>jdk.tools</groupId>
                </exclusion>
                    <exclusion>
                        <groupId>io.netty</groupId>
                        <artifactId>netty-all</artifactId>
                    </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-mapreduce-client-core</artifactId>
            <version>${hadoop.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-common</artifactId>
            <version>${hadoop.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>org.apache.htrace</groupId>
                    <artifactId>htrace-core</artifactId>
                </exclusion>
            </exclusions>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.elasticsearch</groupId>
            <artifactId>elasticsearch</artifactId>
            <version>${elasticsearch.version}</version>
        </dependency>
        <dependency>
            <groupId>org.elasticsearch.client</groupId>
            <artifactId>transport</artifactId>
            <version>${elasticsearch.version}</version>
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>${hutool.version}</version>
        </dependency>
    </dependencies>

四、Elasticsearch建立索引表

#创建索引，并指定副本数和分片数
PUT user_test
{
  "settings": {
    "number_of_replicas": 1
    , "number_of_shards": 5
  }
}
#确定表索引结构
PUT user_test/_mapping/user_test_type
{
  "user_test_type":{
    "properties":{
      "name":{"type":"text"},
      "city":{"type":"text"},
      "province":{"type":"text"},
      "interest":{"type":"text"},
      "followers_count":{"type":"long"},
	  "friends_count":{"type":"long"},
	  "statuses_count":{"type":"long"}
    }
  }
}

五、协处理安装和卸载

  1. 准备工作：将协处理器代码打成jar包，上传至HDFS目录下，本例子是上传到"/" 目录下
  2. 协处理安装
disable 'user_test_index' #禁用hbase表
alter 'user_test_index' , METHOD =>'table_att','coprocessor'=>'/hbase-coprocessor-1.6-SNAPSHOT-jar-with-dependencies.jar|com.xxx.hbase.coprocessor.UniversalHBase2Index|1001|index=user_test,type=user_test_type' 
enable 'user_test_index' #启用表
desc  'user_test_index' #查看协处理器是否安装成功，这里仅仅是查看安装状态，真正是否生效还需要查看put数据时，ES是否收到数据
#参数说明
#user_test：hbase表表名
#hbase-coprocessor-1.6-SNAPSHOT-jar-with-dependencies.jar:协处理器jar包
#com.xxx.hbase.coprocessor.UniversalHBase2Index:协处理器全类名
#index:填入Elasticsearch index表
#type:填入index表对应Type
#注意：修改协处理器代码后，要使新的协处理生效需要先卸载表原有协处理器，然后将jar包打包下来修改名字（重点）上传至hdfs系统，后重新安装，安装时使用新的jar包名。
#为什么要修改jar包名：因为安装完协处理器后，RegionSever已经将jar包加载到JVM中去了，如果不修改名称，重新装载还是会找到原来的jar，并不会替换。
  1. 协处理器卸载
disable 'user_test_index' #禁用表
alter 'user_test_index', METHOD => 'table_att_unset', NAME => 'coprocessor$1'
enable 'user_test_index'
desc  'user_test_index'

五、流程测试与问题留言

  1. 上传协处理器jar包到hdfs
    在这里插入图片描述
  2. 安装协处理器
    disable等操作就不演示了
    在这里插入图片描述
  3. 测试插入数据
    插入数据前一定要在Elasticsearch建立好对应的索引表（按照步骤四进行即可）
    在这里插入图片描述
  4. Elasticsearch查询数据是否入库
    在这里插入图片描述
    发现数据已经成功入库
  5. 问题与留言
    本文实现了HBase建立二级索引的通用协处理器，对某张表安装协处理器时，只需要指定其对应的index名与type名，不需要多次开发。
    有问题的小伙伴可以留言，欢迎交流与探讨！

参考文章：

  1. HBase（八）HBase的协处理器
  2. Hbase 协处理器之将数据保存到es （二级索引）
rookie`
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
hbase2.1.6协处理器使用
01-20
对于2.1.6这个版本，使用协处理器需要引入hbase-common依赖。 协处理器分为两种，一种是observer协处理器，一种是endpoint协处理器。 下面首先记录第一种协处理器的使用步骤。 一、observer协处理器 案例背景 有user和people两个表，每个表都有一个person列族。现在要实现的是向user表插入“person:name”之前，先将其rowkey插入到people表的“person:lastname”。相当于是二级索引的概念。 步骤 1.修改配置文件hbase-site.xml，保证在协处理器加载和运行出现异常时，regionserver仍然可以提供服务。
HBase和ElasticSearch整合构建二级索引
qq_36382679的博客
09-01 577
HBase和ElasticSearch整合构建二级索引 1 maven的pom文件的配置 <dependencies> <!--es客户端--> <dependency> <groupId>org.elasticsearch.client</groupId> <artifactId>transport</artifactId>
联合篇1：elasticsearch作为hbase的二级索引
qq_38740498的博客
05-28 1480
联合篇1：elasticsearch作为hbase的二级索引
Hbase二级索引
mrye的博客
07-19 1484
HBase的查询都是通过RowKey(要把多条件组合查询的字段都拼接在RowKey中显然不太可能)，或者全表扫描再结合过滤器筛选出目标数据(太低效)，所以通过设计HBase的二级索引来解决这个问题。 多个查询条件构成了多维度的组合查询，需要根据不同组合查询出符合条件的数据。 例如: 按照电影维度查询数据适合,但是按照uid就不适合 , 使用二级索引分两步查询实现高效获取数据,因为两次都是通过ROWKEY查询的数据 创建代码实现 思路 在插入数据的时候 , 如果遇到uid属性...
笨鸟的平凡之路-简述hbase的二级索引和协处理器
笨鸟的平凡之路
06-06 183
何为Hbase的二级索引? 在hbase中并不是所有的查询维度都可以依靠rowkey来完成,rowkey的索引单一,对于多维度的查询比较困难,不是所有的列信息都包含在了rowkey中.一般的,当我们知道某一列的某一个值F:C1-C11的时(F为列簇,C11为C1列下的具体值),但是并不知道其对应的rowkey,并且我们还想获取F:C2:C21的值.这时我们可以对F:C1这列建索引,我们需要做的是建...
Elasticsearch安装、增删改查、聚合和Kibanna
a2868221132的博客
12-10 1769
Elasticsearch具备以下特点： 分布式，无需人工搭建集群（solr就需要人为配置，使用Zookeeper作为注册中心） Restful风格，一切API都遵循Rest原则，容易上手 近实时搜索，数据更新在Elasticsearch中几乎是完全同步的 基本概念 索引（indices）-------------------------Databases 数据库 类型（type）-----------------------------Table 数据表 文档（Document）-----------
Hbase使用Coprocessor构建二级索引
lzf的博客
03-17 738
为什么需要二级索引 Hbase默认只支持对行键的索引，那么如果需要针对其它的列来进行查询，就只能全表扫描了。表如果较大的话，代价是不可接受的，所以要提出二级索引的方案。网上的实现方法很多，华为，360等公司都有自己的方案，其中华为的已经开源，但是貌似对源码改动较大，新手不容易接受，所以没有选择它们。而其它的像利用Phoenix，solr等外部框架构建索引对Hbase的学习并没有太大的帮助。综上所...
如何实现HBase的二级索引
最新发布
weixin_59295776的博客
09-06 268
方案二: 基于Phoenix实现, Phoenix是一款基于hbase的SQL客户端, 可以使用SQL的方式来操作hbase, 同时为了提升整体的查询性能, Phoenix中提供了各种索引(全局索引, 本地索引, 覆盖索引以及函数索引), 这些索引都是基于Hbase的协处理器(主要是ObServer协处理器)而实现的, 二级索引的查询方案, 也是Phoenix实现hbase二级索引的方式。
基于 Elasticsearch 存储的HBase二级索引方案
IT- 研究者
05-06 699
基于HBase的存储方案并没解决数据的高效检索问题。在实际应用中，经常有根据特定的几个字段进行组合后检索的应用场景，而HBase采用row key作为索引，不支持多条件查询。 由于在HBase中，表的每行都是按照RowKey的字典序排序存储，表的数据是按照RowKey区间进行分割存储成多个region，所以HBase主要适用下面这两种常见场景：适用于基于rowkey的单行数据快速随机读写、适合基于rowkey前缀的范围扫描。 HBase里面只有rowkey作为一级索引，...
一篇看懂hbase协处理器
qq_36297093的博客
07-01 536
目录 1.hbase高级编程 1. 1. 协处理器—Coprocessor 1. 2. Observer 1. 3. Endpoint 1. 4. 协处理加载方式 1. 4. 1. 静态加载 1. 4. 2. 静态卸载 1. 4. 3. 动态加载 1. 4. 4. 协处理器卸载 2. ...
HBase二级索引实现方案
04-12
本方案主要参照了华为公布的HBase二级索引实现方案。为每个DataTable创建一个与之对应的IndexTable，通过各种途径，保证IndexTable Region与DataTable Region一一对应，并且存储在同一个RegionServer上。
hbase创建二级索引
01-22
public class IndexBuilder3 extends Configured{ public static class MapperIndex extends TableMapper<ImmutableBytesWritable,Put>{ private String tableName; private String columnFamily; private String[] qualifiers; //列为key，索引表表名为value private Map<byte[],ImmutableBytesWritable> indexs = new HashMap<byte[],ImmutableBytesWritable>(); @SuppressWarnings("deprecation") @Override protected void map(ImmutableBytesWritable key, Result value, Context context) throws IOException, InterruptedException { //获取所有需要建索引的列 Set<byte[]> keys = indexs.keySet(); for (byte[] k:keys){ // 该列对应的索引表名字
基于协处理器的HBase二级索引方法.pdf
09-25
基于协处理器的HBase二级索引方法.pdf
基于协处理器的HBase分类二级索引设计.pdf
09-25
基于协处理器的HBase分类二级索引设计.pdf
hbase的rowkey设计与hbase的协处理器运用.docx
09-01
该文档是介绍hbase的rowkey设计与hbase的协处理器运用，与大家分享！
基于CDH的Solr+Hbase+KV构建二级索引
01-07
3.构建二级索引 3.1创建测试表 3.1.1创建测试表（phoenix） drop table “ZJS_ORDER”.”ALADIN_WAYBILLSTATUS”; CREATE TABLE “ZJS_ORDER”.”ALADIN_WAYBILLSTATUS” (  ydh varchar NOT NULL PRIMARY KEY,  ...
HBase协处理器同步二级索引到Solr
weixin_33994444的博客
02-17 133
一、 背景二、 什么是HBase的协处理器三、 HBase协处理器同步数据到Solr四、 添加协处理器五、 测试六、 协处理器动态加载 一、 背景 在实际生产中，HBase往往不能满足多维度分析，我们能想到的办法就是通过创建HBase数据的二级索引来快速获取rowkey，从而得到想要的数据。目前比较流行的二级索引解决方案有Lily HBase Indexer，Phoenix自带...
HBase 协处理器实现二级索引
weixin_30399871的博客
11-26 190
HBase在0.92之后引入了coprocessors，提供了一系列的钩子，让我们能够轻易实现访问控制和二级索引的特性。下面简单介绍下两种coprocessors，第一种是Observers，它实际类似于触发器，第二种是Endpoint，它类似与存储过程。由于这里只用到了Observers，所以只介绍Observers，想要更详细的介绍请查阅（https://blogs.apache....
hbase二级索引es和phoenix
06-06
ES（Elasticsearch）是一种基于Lucene的搜索引擎，可以快速地索引和搜索大量的数据。在HBase中使用ES作为二级索引，可以将HBase中的数据同步到ES中，然后通过ES的搜索功能来查询数据。这种方式适用于需要进行全文...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值